动态规划与递归算法 M苹果放N盘子

最新推荐文章于 2021-11-13 00:13:19 发布

whing123

最新推荐文章于 2021-11-13 00:13:19 发布

阅读量3.1k

点赞数 5

分类专栏：算法与数据结构文章标签：动态规划递归算法

算法与数据结构专栏收录该内容

10 篇文章 0 订阅

订阅专栏

问题：
把 M 个同样的苹果放在 N 个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？
注意：5、1、1 和 1、5、1 是同一种分法，即顺序无关。

来源：牛客

分析：

难点: 当苹果大于盘子时，怎么确定有多少种放法，此时我们考虑了分类
思路来源: 分类计数原理：完成一件事情有n类办法，那么完成这件事共有N=m1+m2+…+mn 种不同的方法
分类：
分为有空盘和没有空盘的两种情况
检查分类：
1. 完备性
  是否囊括所有情况：所有的放苹果方法，要么有空盘，要么没有空盘
2. 分类是否重复
  一类有空盘，一类无空盘，不会重复
分类后，如何操作可以保证满足分类条件：
1. 保证有空盘
  单独拿一个盘子不放，此时的情形，相当于f(apple, plate-1)
2. 保证没有空盘
  首先每个盘子放一个苹果，这样就可以保证没有空盘，此时的情形，相当于f(apple-plate,plate)

总结：
1. 递归出口：当只有一个盘子或者含有 0 个或1个苹果的时候只有一种方法
2. 当盘子数 n 大于苹果数 m 时，则必有 n - m 个空盘子，所以只需求 m 个盘子放 m 个苹果时的方法数即可
3. 当盘子数 n 小于等于苹果数 m 时，总方法数 = 当含有一个空盘子时的方法数+不含空盘子时的方法数。

原因：当在求只含有一个空盘子时的方法数时，已经包含了含有 2 ~ n - 1 个空盘子的情况。
不含空盘子的计算：先将每个盘子装一个苹果，则问题变成了求 n 个盘子放 m - n个苹果的方法数了。

求解：

递归算法

#include <iostream>
using namespace std;

int dp(int m, int n)
{
    // 递归出口：有0个苹果 || 只有1个盘子
    if (m == 0 || n == 1)
        return 1;
    if (n>m) // 盘子比较多，肯定有空盘子，去掉必空的盘子
        return dp(m, m);
    else // 苹果比较多：
        // 1：至少有一个空盘子，拿掉这个空盘子
        // 2：每个盘子都有苹果，各拿掉一个苹果（极限是最少的有1个苹果）
        return dp(m, n - 1) + dp(m - n, n);
}

int main()
{
    int m, n;
    while (cin >> m >> n)
        cout << dp(m, n) << endl;
    return 0;
}

动态规划
新建一个动态规划表 dp；dp[i][j] 表示 i 个盘子放 j 个苹果的方法数。
当 i > j 时，dp[i][j] = dp[i - (i - j)][j] = dp[j][j] （原因上面已经讲过）
当 i <= j 时，dp[i][j] = dp[i - 1][j] + dp[i][j - i];
最后dp[n][m] 就是所求。

int** getdp1 (int m, int n)
{
    if( m == 0 || m == 1 || n == 1 )
    {
        return NULL;
    }
    int **dp = new int *[n + 1];
    for( int i = 0; i <= n; i++ )
    {
        dp[i] = new int[m + 1];
        for( int j = 0; j <= m; j++ )
        {
            dp[i][j] = 1;
        }
    }

    for( int i = 2; i <= n; ++i)
    {
        for( int j = 2; j <= m; ++j)
        {
            if( i > j )
            {
                dp[i][j] = dp[j][j];
            }
            else
            {
                dp[i][j] = dp[i - 1][j] + dp[i][j - i];
            }
        }
    }
    return dp;
}

int putApple2 (int m, int n)
{
    if( m == 0 || m == 1 || n == 1 )
    {
        return 1;
    }
    int **dp = getdp1 (m, n);
    return dp[n][m];
}

问题变形：
整数划分的一种：求将一个整数m至多划分成n个数有多少种情况

变形：求将一个整数m划分成n个数有多少种情况
dp[m][n] = dp[m-n][n] + dp[m-1][n-1]; 对于变形后的问题，存在两种情况：
1. n 份中不包含 1 的分法，为保证每份都 >= 2，可以先拿出 n 个 1 分到每一份，然后再把剩下的 m- n 分成 n 份即可，分法有: dp[m-n][n]
2. n 份中至少有一份为 1 的分法，可以先那出一个 1 作为单独的1份，剩下的 m- 1 再分成 n- 1 份即可，分法有：dp[m-1][n-1]


import java.util.Scanner;

public class Main {

    public static final int maxn = 25;
    public static void main(String[] args) {

        int[][] dp = new int[maxn][maxn];
        for(int i=1;i<maxn;i++){
            dp[i][1] = 1;
            dp[i][i] = 1;
        }
        for(int i=1;i<maxn;i++){
            for(int j=2;j<maxn;j++){
                if(i>j)
                    dp[i][j] = dp[i-j][j] + dp[i-1][j-1];
                else if(i == j)
                    dp[i][j] = 1;
                else
                    dp[i][j] = 0;
            }
        }

        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int m = sc.nextInt();
            int n = sc.nextInt();
            int res = 0;

            // 回到变形前，至多划分为n个数，而不是只划分为n个数
            for(int i=1;i<=n;i++)
                res += dp[m][i];
            System.out.println(res);
        }
    }
}